let util = {};
import { locale } from 'element-ui/lib/locale/lang/en';


//跳转页面
util.pageChange = function (vmRouter, path, params = {}, target = '_self') {
	window.open(vmRouter.resolve({
		path: path,
		query: params
	}).href, target);
};

//登出
util.logout = function (vm, isJump = true, jumpPath = vm.localeCn?"/":"/en") {
	vm.$store.dispatch("LogOut", vm);
	if (jumpPath) {
		vm.$router.push({
			path: jumpPath
		});
	}
};

// 时间格式化 
util.parseTime = function (time, pattern) {
	if (arguments.length === 0 || !time) {
		return null
	}
	const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}'
	let date
	if (typeof time === 'object') {
		date = time
	} else {
		if ((typeof time === 'string') && (/^[0-9]+$/.test(time))) {
			time = parseInt(time)
		} else if (typeof time === 'string') {
			time = time.replace(new RegExp(/-/gm), '/').replace('T', ' ').replace(new RegExp(/\.[\d]{3}/gm), '');
		}
		if ((typeof time === 'number') && (time.toString().length === 10)) {
			time = time * 1000
		}
		date = new Date(time)
	}
	const formatObj = {
		y: date.getFullYear(),
		m: date.getMonth() + 1,
		d: date.getDate(),
		h: date.getHours(),
		i: date.getMinutes(),
		s: date.getSeconds(),
		a: date.getDay()
	}
	const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
		let value = formatObj[key]
		// Note: getDay() returns 0 on Sunday
		if (key === 'a') { return ['日', '一', '二', '三', '四', '五', '六'][value] }
		if (result.length > 0 && value < 10) {
			value = '0' + value
		}
		return value || 0
	})
	return time_str
}

// 如果路径中含 .html 传参的时候需要去掉
util.removeDot = function (data) {
	return util.getBefore(data, '.')
}

// 将日期的分隔符 - 换为 /
util.replaceDateDivision = function (date) {
	if (!date) return
	return date.replace(/-/g, '/')
}

/**
 * 如果日期相同时，就合并为只显示一个日期
 * 2021/09/14 09:00:00 - 2021/09/14 20:00:00 转为 2021/09/14 09:00:00 - 20:00:00
*/
util.joinSameDate = function (dateTime) {
	if (!dateTime) return
	let d1 = dateTime.split('-')[0].trim().replace(/\s+/g, '###')
	let d2 = dateTime.split('-')[1].trim().replace(/\s+/g, '###')
	let d1Date = d1.split('###')[0]
	let d2Date = d2.split('###')[0]
	let d1Time = d1.split('###')[1]
	let d2Time = d2.split('###')[1]
	if (d1Date == d2Date) {
		return `${d1Date} ${d1Time?d1Time:''} ${d1Time&&d2Time?'-':''} ${d2Time?d2Time:''}`
	} else {
		return dateTime
	}
}
/**
 * 如果日期年份相同时，就合并为只显示一个年份 2023/04/20,2023/05/20  -->2023/04/20-05/20
 * 如果日期年份和月份相同时，就合并为只显示一个年份和月份 2023/04/20,2023/04/23  -->2023/04/20-23
 * 
*/
util.joinDate = function (start, end) {
	if (!start || !end) return
    const startArr = util.replaceDateDivision(start).split('/')
    const endArr = util.replaceDateDivision(end).split('/')
    const year = startArr[0]
    const year2 = endArr[0]
    const month = startArr[1]
    const month2 = endArr[1]
    const day = startArr[2]
    const day2 = endArr[2]
    // 年不同 不处理
    if (startArr[0] != endArr[0]) {
        return `${start}-${end}`
        // 年相同
    } else {
        // 月不同 不处理
        if (startArr[1] != endArr[1]) {
            return `${year}/${month}/${day}-${month2}/${day2}`
            // 月相同
        } else {
            // 日期不同 进行处理 
            if (startArr[2] != endArr[2]) {
                return `${year}/${month}/${day}-${day2}`
            // 日期相同 不处理     
            } else {
                return `${year}/${month}/${day}`
            }
        }
    }
}

/**
 * 如果日期年份相同时，就合并为只显示一个年份 2023/04/20,2023/05/20  -->20 April - 20 May,2023
 * 如果日期年份和月份相同时，就合并为只显示一个年份和月份 2023/04/20,2023/04/23  -->  20-23 April,2023
 * 
*/
util.joinDateEn = function (start, end) {
	if (!start || !end) return
    const startArr = util.replaceDateDivision(start).split('/')
	const endArr = util.replaceDateDivision(end).split('/')
	const listMonth = [
		'',
		'January',
		'February',
		'March',
		'April',
		'May',
		'June',
		'July',
		'August',
		'September',
		'October',
		'November',
		'December',
	]
    const year = startArr[0]
    const year2 = endArr[0]
    const month = startArr[1]
    const month2 = endArr[1]
    const day = startArr[2]
    const day2 = endArr[2]
    // 年不同
    if (startArr[0] != endArr[0]) {
        return `${day} ${listMonth[month*1]},${year} - ${day2} ${listMonth[month2*1]},${year2}`
        // 年相同
    } else {
        // 月不同
        if (startArr[1] != endArr[1]) {
			return `${day} ${listMonth[month*1]}-${day2} ${listMonth[month2*1]},${year}`
            // 月相同
        } else {
            // 日期不同
            if (startArr[2] != endArr[2]) {
				return `${day}-${day2} ${listMonth[month*1]},${year}`
            // 日期相同
            } else {
                day = startArr[2]
				return `${day} ${listMonth[month*1]},${year}`
            }
        }
    }
}
// 在数组中依据 title 查找对应的 对象
util.findObjFromTitle = function (list, title) {
	if (title == undefined || title == null) {//此处可能会有0值
		return '';
	}
	if ((!list) || list.length == 0) {
		return '';
	}
	let data = list.find((item) => {
		return item.title == title
	})
	return data ? data : []
}


// 在数组中依据 value 查找对应的 label
util.findLabelFromVal = function (list, val) {
	console.log("findLabelFromVal:", list, val)
	if (val == undefined || val == null) {//此处可能会有0值
		return '';
	}
	if ((!list) || list.length == 0) {
		return '';
	}
	let data = list.find((item) => {
		return item.value == val
	})
	return data ? data['label'] : ''
}
// 在数组中依据 value 查找对应的 labelEn
util.findLabelEnFromVal = function (list, val) {
	if (val == undefined || val == null) {//此处可能会有0值
		return '';
	}
	if ((!list) || list.length == 0) {
		return '';
	}
	let data = list.find((item) => {
		return item.value == val
	})
	return data ? data['labelEn'] : ''
}
/**
 * 获取字典数据中的raw内的字段到上一级
*/
util.setDictRaw2Up = function (list) {
	if ((!list) || list.length == 0) {
		return [];
	}
	list.forEach(item => {
		for (let attr in item.raw) {
			if (attr == 'dictLabelEn') {
				item['labelEn'] = item.raw[attr]
			}
		}
		delete item.raw
	})
	return list
}
/**
 * 一维数组拆分为 每个数组包含num个元素的二维数组 
 */
util.sliceIntoChunks = function (arr,num) {
	if (!arr || arr.length == 0) return
	const res = [];
    for (let i = 0; i < arr.length; i += num) {
        const chunk = arr.slice(i, i + num);
        res.push(chunk);
    }
    return res;
}
/**
 * 在一个数组内查找另一个数组里的符合前一个数组的元素
 * 举例：在数组[{id:2,label:'22'},{id:3,label:'33'},{id:4,label:'44'},]中找id为[2,3] 的item
 * @currentArr 选中的数组
 * @dataArr 原数据
 * @prop 需要对照的属性
*/

util.findArrItemInArr = function (currentArr, dataArr, prop="id") {
    const targetArrIndex = [] //原数组中找到的元素的下标
    const targetArr = [] // 原数组中找到的元素，组成的数组
    currentArr.forEach(item => {
        dataArr.forEach((itemJ,j) => {
            if (item == itemJ[prop]) {
                targetArrIndex.push(j) // 存入符合要求的index 
                targetArr.push(itemJ) // 存入符号要求的item
                dataArr[j].select=true // 改变原数组的某个属性
            } 
        })
    })
    return {
        targetArrIndex,
        targetArr
    }
}

export default util;
